• Viernes 8 de Noviembre de 2024, 16:49
« anterior próximo »
Páginas: [1]

Autor Tema:  Algoritmo Formula  (Leído 2523 veces)

gemma

  • Nuevo Miembro
  • *
  • Mensajes: 21
    • Ver Perfil
Algoritmo Formula
« en: Lunes 3 de Marzo de 2008, 16:58 »
0
Hola quisiera saber si hay algun algoritmo para resolver formulas.

Me explico que de una formula que tenga que resolver despege el orden en que tiene que hacer la formula con los operadores, etcc.

Gracias Anticipadas.

SteelX

  • Miembro MUY activo
  • ***
  • Mensajes: 218
    • Ver Perfil
Re: Algoritmo Formula
« Respuesta #1 en: Lunes 3 de Marzo de 2008, 17:19 »
0
no creo que exista un solo algoritmo para resolver formulas, matemáticas, físicas o quimicas, por otra parte si existen librerías matématicas y de otras categorias.
Inside the code

gemma

  • Nuevo Miembro
  • *
  • Mensajes: 21
    • Ver Perfil
Re: Algoritmo Formula
« Respuesta #2 en: Lunes 3 de Marzo de 2008, 18:07 »
0
Lo siento me referia a formulas matematicas

SteelX

  • Miembro MUY activo
  • ***
  • Mensajes: 218
    • Ver Perfil
Re: Algoritmo Formula
« Respuesta #3 en: Lunes 3 de Marzo de 2008, 22:48 »
0
Inside the code

emuller

  • Miembro MUY activo
  • ***
  • Mensajes: 104
    • Ver Perfil
Re: Algoritmo Formula
« Respuesta #4 en: Lunes 3 de Marzo de 2008, 23:18 »
0
No estoy seguro a que te referís, pero encontré ésto: http://www.infor.uva.es/~cvaca/asigs/AlgInfPost.htm
Mi deseo: que le otorguen el premio Nobel de la paz al inventor del Copy & Paste. Gracias por evitarme tantas peleas con el tiempo y aumentar la esperanza de vida de mi teclado \":)\"

su -

  • Moderador
  • ******
  • Mensajes: 2349
    • Ver Perfil
Re: Algoritmo Formula
« Respuesta #5 en: Martes 4 de Marzo de 2008, 01:51 »
0
*******PELIGRO LEE ESTO!!*******

There is no place like 127.0.0.1

Conecto luego existo, no conecto luego insisto.

arntracks

  • Nuevo Miembro
  • *
  • Mensajes: 3
    • Ver Perfil
Re: Algoritmo Formula
« Respuesta #6 en: Martes 18 de Marzo de 2008, 07:55 »
0
Cita de: "gemma"
Lo siento me referia a formulas matematicas
Sería bueno que explicaras mejor el algoritmo que necesitas... si pones un ejemplo seguro que lo entenderemos mejor.

Karman

  • Miembro activo
  • **
  • Mensajes: 84
    • Ver Perfil
    • http://www.inexinferis.com.ar
Re: Algoritmo Formula
« Respuesta #7 en: Miércoles 19 de Marzo de 2008, 15:21 »
0
fijate esta pequeña librería:

Calculadora de funciones en strings del tipo:

"2^5/(2*8)+9^(1/2)-(ln(e(1)))*(cos(25)-sin(60))"

fue algo que me llevó mucho tiempo hacer y que lo hice sin nada de referencia así que posiblemente pueda ser optimizado...   :kicking:

source C
Código
Código: Text
  1.  
  2. /*
  3.   Name: StrCalc.c
  4.   Copyright: Exinferis Inc.- 1999-2006
  5.   URL: http://www.inexinferis.co.nr
  6.   Author: Karman
  7.   Date: 12/05/05 15:13
  8.   Version: 0.95
  9.   Description: Calculadora de Strings...
  10.  
  11.   Operandos:
  12.     Enteros, Reales y ()
  13.   Operaciones Permitidas:
  14.     Matemáticas:
  15.       + - / * % ^
  16.     Funciones:
  17.       asin(x) - ArcoSeno
  18.       acos(x) - ArcoCoseno
  19.       atan(x) - ArcoTangente
  20.       abs(x)  - Absoluto (+)
  21.       sin(x)  - Seno
  22.       sinh(x) - Seno hiperbólico
  23.       cos(x)  - Coseno
  24.       cosh(x) - Coseno hiperbólico
  25.       tan(x)  - Tangente
  26.       tanh(x) - Tangente hiperbólica
  27.       ln(x)   - Logaritmo natural
  28.       log(x)  - Logaritmo base 10
  29.       e(x)    - e a la n
  30.       rand(x) - Número aleatorio
  31.       rnd(x)  - Redondeo
  32.       int(x)  - Truncado a entero
  33.  
  34.   Example:
  35.  
  36.     Calculate("2^5/(2*8)+9^(1/2)-(ln(e(1)))*(cos(90)-sin(90))");
  37. */
  38. #include "strcalc.h"
  39.  
  40. //Modo radianes (rad=1) modo normal (rad=0)
  41. char rad=0;
  42. char *fstart=0,*errpos=0;
  43.  
  44. //Funciones válidas
  45. FUNC func[]={
  46.   {"asin(",'a'},{"acos(",'b'},{"atan(",'d'},{"abs(",'j'},{"sin(",'s'},
  47.   {"sinh(",'f'},{"cos(",'c'},{"cosh(",'g'},{"tan(",'t'},{"tanh(",'h'},
  48.   {"ln(",'n'},{"log(",'l'},{"e(",'e'},{"rand(",'r'},{"rnd(",'u'},{"int(",'i'}
  49. };
  50.  
  51. //********************************************************
  52. // Devuelve la posición del error... (si hubo alguno)
  53. //********************************************************
  54. unsigned char GetFunctionErrorPos(void){
  55.   return (unsigned char)(errpos-fstart);
  56. }
  57. //********************************************************
  58. // Devuelve el error... (si hubo alguno)
  59. //********************************************************
  60. char *GetFunctionError(void){
  61.   return errpos;
  62. }
  63. //********************************************************
  64. // Libera lista en caso de error...
  65. //********************************************************
  66. void freelist(PCALCS prim){
  67.   PCALCS tmp;
  68.   while(prim){
  69.     tmp=prim;prim=prim->sig;free(tmp);
  70.   }
  71. }
  72. //********************************************************
  73. // Calcula lista de operaciones-operandos...
  74. //********************************************************
  75. double CalcOp(PCALCS pcy){
  76.   double res=0;PCALCS tpcy;
  77.   while(pcy){
  78.     switch(pcy->op){
  79.       case '=':res=pcy->val;break;
  80.       case '^':res=pow(res,pcy->val);break;
  81.       case '%':res=fmod(res,pcy->val);break;
  82.       case '*':res=res*pcy->val;break;
  83.       case '/':res=res/pcy->val;break;
  84.       case '+':res=res+pcy->val;break;
  85.       case '-':res=res-pcy->val;break;
  86.       //Arc trig. functions
  87.       case 'a':
  88.         if(rad)res=asin(pcy->val);
  89.         else res=(asin(pcy->val)*180)/M_PI;
  90.       break;
  91.       case 'b':
  92.         if(rad)res=acos(pcy->val);
  93.         else res=(acos(pcy->val)*180)/M_PI;
  94.       break;
  95.       case 'd':
  96.         if(rad)res=atan(pcy->val);
  97.         else res=(atan(pcy->val)*180)/M_PI;
  98.       break;
  99.       //Trig. Functions
  100.       case 's':
  101.         if(rad)res=sin(pcy->val);
  102.         else res=sin((pcy->val*M_PI)/180);
  103.       break;
  104.       case 'c':
  105.         if(rad)res=cos(pcy->val);
  106.         else res=cos((pcy->val*M_PI)/180);
  107.       break;
  108.       case 't':
  109.         if(rad)res=tan(pcy->val);
  110.         else res=tan((pcy->val*M_PI)/180);
  111.       break;
  112.       //Hip. Functions
  113.       case 'f':res=sinh(pcy->val);break;
  114.       case 'g':res=cosh(pcy->val);break;
  115.       case 'h':res=tanh(pcy->val);break;
  116.       //Other functions
  117.       case 'n':res=log(pcy->val);break;
  118.       case 'l':res=log10(pcy->val);break;
  119.       case 'e':res=exp(pcy->val);break;
  120.       case 'j':res=fabs(pcy->val);break;
  121.       case 'r':res=fmod(rand(),pcy->val);break;
  122.       case 'i':modf(pcy->val,&res);break;
  123.       case 'u':res=ceill(pcy->val);break;
  124.       default:res=0;
  125.     }
  126.     tpcy=pcy;pcy=pcy->sig;free(tpcy);
  127.   }
  128.   return res;
  129. }
  130. //********************************************************
  131. // Obtiene el número del String...
  132. //********************************************************
  133. double GetNum(char **txt){
  134.   double tmp=0;unsigned char des=0;
  135.   while((**txt)&&(isdigit(**txt)||((**txt)=='.')||((**txt)==' '))){
  136.     //Controlamos espacios en blanco...
  137.     if(**txt==' '){
  138.       while(**txt==' ')(*txt)++;
  139.       continue;
  140.     }
  141.     if((**txt)=='.')
  142.       if(des){
  143.         errpos=*txt;
  144.         return 0;
  145.       }else{
  146.         des=1;
  147.         (*txt)++;
  148.         continue;
  149.       }
  150.     if(des)
  151.       tmp=tmp+((*((*txt)++)-0x30)/pow(10,des++));
  152.     else
  153.       tmp=(tmp*10)+(*((*txt)++)-0x30);
  154.   }
  155.   if(des&&tmp==0){
  156.     errpos=*txt;
  157.     return 0;
  158.   }
  159.   else return tmp;
  160. }
  161. //********************************************************
  162. // Genera lista de Operadores-Operandos y administra
  163. // resultados... (recursivo)
  164. //********************************************************
  165. static double Calc(char **py,char lop,double lval){
  166.   char *pyt,*opy,cp,trig,tmp[256];
  167.   unsigned char av,flen,nfunc=sizeof(func)/sizeof(func[0]);
  168.   PCALCS prim=NULL,tp=NULL,atp=NULL,tq,tt;
  169.   while(**py){
  170.     //Controlamos espacios en blanco...
  171.     while(**py==' ')*py++;
  172.     //Nuevo elemento...
  173.     if(tp)atp=tp;
  174.     tp=(PCALCS)malloc(sizeof(CALCS));
  175.     if(!prim)prim=tp;else tq->sig=tp;
  176.     tq=tp;tp->sig=NULL;  
  177.     //Operación?
  178.     if(lval){//Argumento enviado...
  179.       tp->val=lval;tp->op='=';lval=0;continue;
  180.     }
  181.     //primer operación...
  182.     if(isoper(**py))//Es una operación?
  183.       switch(**py){
  184.         //Suma Resta prioridad 3...
  185.         case '+':case '-':
  186.           switch(lop){
  187.             case '*':case '^':case '%':
  188.               atp->sig=NULL;free(tp);
  189.               return CalcOp(prim);
  190.             case '+':
  191.               tp->op=*(*py)++;
  192.             break;
  193.             default:
  194.               goto OnError;//Error...
  195.           }
  196.         break;
  197.         //Multiplicación Divición prioridad 2...
  198.         case '*':case '/':
  199.           switch(lop){
  200.             case '^':case '%':
  201.               atp->sig=NULL;free(tp);
  202.               return CalcOp(prim);
  203.             case '*':tp->op=*(*py)++;break;
  204.             case '+':
  205.               atp->val=Calc(&(*py),'*',atp->val);
  206.               atp->sig=NULL;free(tp);tp=NULL;tq=atp;
  207.               if(errpos!=fstart)
  208.                 goto OnError;//Error...
  209.             continue;
  210.             default:
  211.               goto OnError;//Error...
  212.           }
  213.         break;
  214.         //Modulo prioridad 1...
  215.         case '%':
  216.           switch(lop){
  217.             case '^':
  218.               atp->sig=NULL;free(tp);
  219.               return CalcOp(prim);
  220.             case '%':tp->op=*(*py)++;break;
  221.             case '+':case '*':
  222.               atp->val=Calc(&(*py),'%',atp->val);
  223.               atp->sig=NULL;free(tp);tp=NULL;tq=atp;
  224.               if(errpos!=fstart)
  225.                 goto OnError;//Error...
  226.             continue;
  227.             default:
  228.               goto OnError;//Error...
  229.           }
  230.         break;
  231.         //Potencia prioridad 0...
  232.         case '^':
  233.           switch(lop){
  234.             case '^':tp->op=*(*py)++;break;
  235.             case '+':case '*':case '%':
  236.               atp->val=Calc(&(*py),'^',atp->val);
  237.               atp->sig=NULL;free(tp);tp=NULL;tq=atp;
  238.               if(errpos!=fstart)
  239.                 goto OnError;//Error...
  240.             continue;
  241.             default:
  242.               goto OnError;//Error...
  243.           }
  244.         break;
  245.         default:
  246.           goto OnError;//Error...
  247.       }
  248.     else //Restantes opciones...
  249.       tp->op='=';
  250.     //Obtenemos argumento...
  251.     if(isdigit(**py)||((**py)=='.')){
  252.       tp->val=GetNum(&(*py));
  253.       if(errpos!=fstart)
  254.         goto OnError;//Error...    
  255.     }else{
  256.       trig=0;
  257.       //Parentesis...
  258.       if(**py=='(')goto CalcCont;
  259.       //Funciones...
  260.       for(av=0;av<nfunc;av++){
  261.         flen=strlen(func[av].fname);
  262.         if(!strncmp(*py,func[av].fname,flen)){
  263.           (*py)+=flen-1;trig=func[av].func;
  264.           goto CalcCont;
  265.         }
  266.       }
  267.       //Tratamos Error...
  268.       goto OnError;//Error...
  269. CalcCont://Calculamos contenido de "()"
  270.       pyt=tmp;cp=1;(*py)++;opy=*py;
  271.       while(**py){
  272.         if(**py=='(')++cp;
  273.         if(**py==')')--cp;
  274.         if(!cp)break;
  275.         *(pyt++)=*(*py)++;
  276.       }
  277.       if(cp)
  278.         goto OnError;//Error...
  279.       *pyt=0;(*py)++;pyt=tmp;
  280.       tp->val=Calc(&pyt,'+',0);
  281.       if(errpos!=fstart){
  282.         *py=opy;
  283.         goto OnError;//Error...
  284.       }
  285.       //Resolvemos funciones...
  286.       if(trig){
  287.         tt=(PCALCS)malloc(sizeof(CALCS));
  288.         tt->sig=NULL;
  289.         tt->op=trig;
  290.         tt->val=tp->val;
  291.         tp->val=CalcOp(tt);
  292.       }
  293.     }
  294.   }
  295.   return CalcOp(prim);
  296.   OnError://Error...
  297.     errpos=*py;
  298.     freelist(prim);
  299.   return 0;
  300. }
  301. //********************************************************
  302. // Verifica String y llama a la función de cálculo...
  303. //********************************************************
  304. double Calculate(char *arg){
  305.   fstart=errpos=arg;
  306.   if(strlen(arg)>256){//256 caracteres Máximo...
  307.     errpos=arg+256;
  308.     return 0;
  309.   }
  310.   return Calc(&arg,'+',0);
  311. }
  312.  
  313.  

source H
Código
Código: Text
  1.  
  2. #ifndef  _STRCALCLIB_H_
  3. #define  _STRCALCLIB_H_
  4.  
  5. #include <string.h>
  6. #include <stdlib.h>
  7. #include <ctype.h>
  8. #include <math.h>
  9.  
  10. //Operaciones válidas
  11. #define isoper(a) (a=='+')||(a=='-')||(a=='*')||(a=='/')||(a=='^')||(a=='%')
  12.  
  13. //********************************************************
  14. // Registro de funciones...
  15. //********************************************************
  16. typedef struct _FUNC_{
  17.   char fname[6],func;
  18. }FUNC;
  19.  
  20. //********************************************************
  21. // Lista de argumentos...
  22. //********************************************************
  23. typedef struct calcs{
  24.   double val;
  25.   char op;
  26.   struct calcs *sig;
  27. }CALCS,*PCALCS;
  28.  
  29. //********************************************************
  30. // Funciones Exportadas...
  31. //********************************************************
  32. double Calculate(char *arg);
  33. unsigned char GetFunctionErrorPos(void);
  34. char *GetFunctionError(void);
  35.  
  36. #endif //_STRCALCLIB_H_
  37.  
  38.  

S2

PD: más info como funciona en mi pag...
Páginas: [1]
« anterior próximo »